90 research outputs found
TCTracer: Establishing test-to-code traceability links using dynamic and static techniques
Test-to-code traceability links model the relationships between test artefacts and code artefacts. When utilised during the development process, these links help developers to keep test code in sync with tested code, reducing the rate of test failures and missed faults. Test-to-code traceability links can also help developers to maintain an accurate mental model of the system, reducing the risk of architectural degradation when making changes. However, establishing and maintaining these links manually places an extra burden on developers and is error-prone. This paper presents TCTracer, an approach and implementation for the automatic establishment of test-to-code traceability links. Unlike existing work, TCTracer operates at both the method level and the class level, allowing us to establish links between tests and functions, as well as between test classes and tested classes. We improve over existing techniques by combining an ensemble of new and existing techniques that utilise both dynamic and static information and exploiting a synergistic flow of information between the method and class levels. An evaluation of TCTracer using five large, well-studied open source systems demonstrates that, on average, we can establish test-to-function links with a mean average precision (MAP) of 85% and test-class-to-class links with an MAP of 92%
05451 Abstracts Collection -- Beyond Program Slicing
From 06.11.05 to 11.11.05, the Dagstuhl Seminar 05451 ``Beyond Program Slicing\u27\u27 was held in the International Conference and Research Center (IBFI),
Schloss Dagstuhl.
During the seminar, several participants presented their current
research, and ongoing work and open problems were discussed. Abstracts of
the presentations given during the seminar as well as abstracts of
seminar results and ideas are put together in this paper. The first section
describes the seminar topics and goals in general.
Links to extended abstracts or full papers are provided, if available
Field-Sensitive Program Slicing
The granularity level of the program dependence graph (PDG) for composite data structures (tuples, lists, records, objects, etc.) is inaccurate when slicing their inner elements. We present the constrained-edges PDG (CE-PDG) that addresses this accuracy problem. The CE-PDG enhances the representation of composite data structures by decomposing statements into a subgraph that represents the inner elements of the structure, and the inclusion and propagation of data constraints along the CE-PDG edges allows for accurate slicing of complex data structures. Both extensions are conservative with respect to the PDG, in the sense that all slicing criteria (and more) that can be specified in the PDG can be also specified in the CE-PDG, and the slices produced with the CE-PDG are always smaller or equal to the slices produced by the PDG. An evaluation of our approach shows a reduction of the slices of 11.67%/5.49% for programs without/with loops
Dependence Cluster Visualization
Large clusters of mutual dependence have long been regarded as
a problem impeding comprehension, testing, maintenance, and reverse
engineering. An effective visualization can aid an engineer
in addressing the presence of large clusters. Such a visualization is
presented. It allows a programâs dependence clusters to be considered
from an abstract high level down thru a concrete source-level.
At the highest level of abstraction, the visualization uses a heat-map
(a color scheme) to efficiently overview the clusters found in an entire
system. Other levels include three source code views that allow
a user to âzoomâ in on the clusters starting from the high-level system
view, down through a file view, and then onto the actual source
code where each cluster can be studied in detail.
Also presented are two case studies, the first is the open-source
calculator bc and the second is the industrial program copia, which
performs signal processing. The studies consider qualitative evaluations
of the visualization. From the results, it is seen that the visualization
reveals high-level structure of programs and interactions
between its components. The results also show that the visualization
highlights potential candidates (functions/files) for re-factoring
in bc and finds dependence pollution in copia
Sentinel: A Hyper-Heuristic for the Generation of Mutant Reduction Strategies
Mutation testing is an effective approach to evaluate and strengthen software
test suites, but its adoption is currently limited by the mutants' execution
computational cost. Several strategies have been proposed to reduce this cost
(a.k.a. mutation cost reduction strategies), however none of them has proven to
be effective for all scenarios since they often need an ad-hoc manual selection
and configuration depending on the software under test (SUT). In this paper, we
propose a novel multi-objective evolutionary hyper-heuristic approach, dubbed
Sentinel, to automate the generation of optimal cost reduction strategies for
every new SUT. We evaluate Sentinel by carrying out a thorough empirical study
involving 40 releases of 10 open-source real-world software systems and both
baseline and state-of-the-art strategies as a benchmark. We execute a total of
4,800 experiments, and evaluate their results with both quality indicators and
statistical significance tests, following the most recent best practice in the
literature. The results show that strategies generated by Sentinel outperform
the baseline strategies in 95% of the cases always with large effect sizes.
They also obtain statistically significantly better results than
state-of-the-art strategies in 88% of the cases, with large effect sizes for
95% of them. Also, our study reveals that the mutation strategies generated by
Sentinel for a given software version can be used without any loss in quality
for subsequently developed versions in 95% of the cases. These results show
that Sentinel is able to automatically generate mutation strategies that reduce
mutation testing cost without affecting its testing effectiveness (i.e.
mutation score), thus taking off from the tester's shoulders the burden of
manually selecting and configuring strategies for each SUT.Comment: in IEEE Transactions on Software Engineerin
Comparison and Evaluation of Clone Detection Tools
Many techniques for detecting duplicated source code (software clones) have been proposed in the past. However, it is not yet clear how these techniques compare in terms of recall and precision as well as space and time requirements. This paper presents an experiment that evaluates six clone detectors based on eight large C and Java programs (altogether almost 850 KLOC). Their clone candidates were evaluated by one of the authors as an independent third party. The selected techniques cover the whole spectrum of the state-of-the-art in clone detection. The techniques work on text, lexical and syntactic information, software metrics, and program dependency graphs
Coherent clusters in source code
This paper presents the results of a large scale empirical study of coherent
dependence clusters. All statements in a coherent dependence cluster depend
upon the same set of statements and aâ”ect the same set of statements; a coherent
clusterâs statements have âcoherentâ shared backward and forward dependence.
We introduce an approximation to efficiently locate coherent clusters and show
that it has a minimum precision of 97.76%. Our empirical study also finds
that, despite their tight coherence constraints, coherent dependence clusters
are in abundance: 23 of the 30 programs studied have coherent clusters that
contain at least 10% of the whole program. Studying patterns of clustering in
these programs reveals that most programs contain multiple significant coherent
clusters. A series of case studies reveals that these major clusters map to logical
functionality and program structure. For example, we show that for the program
acct, the top five coherent clusters all map to specific, yet otherwise non-obvious,
functionality. Cluster visualization can also reveal subtle deficiencies in program
structure and identify potential candidates for refactoring eâ”orts. Finally a
study of inter-cluster dependence is used to highlight how coherent clusters
built are connected to each other, revealing higher-level structures, which can
be used in reverse engineering
- âŠ